/*
* @Author: wyd
* @Date: 2025-01-23 15:33:37
* @LastEditors: fang
* @LastEditTime: 2025-02-20 16:16:18
* @FilePath: \Software\Application\TwoPartMatterApplication\Core\Src\bsp_beep.c
* @Description: 
* 
* Copyright (c) 2025 by ${git_name_email}, All Rights Reserved. 
*/
// #include "bsp_beep.h"
// #include "main.h"
// #include "rthw.h"
// #include "elog.h"

#include "gd32f10x.h"
#include "general_config.h"
// #include "gd32f10x_gpio.h"

#define LOW 0
#define MID 1
#define HIGH 2

// extern uint8_t Red_Flg_test1;//红灯闪烁标志位

volatile uint8_t Beep_one_flg = 0;

volatile uint8_t Beep_one_flg_1 = 0;

extern uint16_t Power_off_time;

volatile uint8_t  Alarm_type;
// #define POWER_DETECT_GPIO   GPIOC
// #define POWER_DETECT_PIN    GPIO_PIN_2

// void gpio_init(void) 
// {
//     rcu_periph_clock_enable(RCU_GPIOC); // 使能 GPIOC 时钟
//     gpio_init(POWER_DETECT_GPIO, GPIO_MODE_IPU, GPIO_OSPEED_50MHZ, POWER_DETECT_PIN); // 上拉输入模式
// }

        // if (gpio_input_bit_get(POWER_DETECT_GPIO, POWER_DETECT_PIN) == RESET) {
            // 断电检测到（GPIO 变低）
            // 执行掉电保存数据等操作

void timer2_init(void) 
{
    rcu_periph_clock_enable(RCU_TIMER2); // 开启 TIM2 时钟
    rcu_periph_clock_enable(RCU_GPIOC); // 使能 GPIOC 时钟
    
    gpio_init(POWER_DETECT_GPIO, GPIO_MODE_IPU, GPIO_OSPEED_50MHZ, POWER_DETECT_PIN); // 上拉输入模式

    gpio_init(POWER_DETECT_GPIO, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, SCAP_Control_PIN);//控制超级给蜂鸣器模块供电
    gpio_bit_set(POWER_DETECT_GPIO, SCAP_Control_PIN);//初始设置为高电平

    timer_deinit(TIMER2); // 复位 TIM2
    timer_prescaler_config(TIMER2, 108 - 1, TIMER_PSC_RELOAD_NOW);  // 108MHz / 108 = 1MHz (1us)
    timer_autoreload_value_config(TIMER2, 0xFFFF); // 最大计数值 65535
    timer_counter_value_config(TIMER2, 0); // 清零计数器
    timer_enable(TIMER2); // 使能 TIM2
}

// void Software_Reset(void) 
// {
// 	// 设置SWRST位为1，触发软件复位
// 	RCU_CTLR |= RCU_CTLR_SWRST;
// }

void timer2_delay_us(uint32_t us) 
{
    uint32_t start = TIMER_CNT(TIMER2); // 获取当前计数
    while ((TIMER_CNT(TIMER2) - start) < us); // 等待 us 时间
}

void timer2_delay_ms(uint32_t ms) 
{
    while (ms--) 
		 {
			 timer2_delay_us(1000);
		 }
}
// /**
//  * @description: 音量调节，参数为1，2，3对应高，中，低音量（注意顺序）
//  * @param {int} volume
//  * @return {*}
//  */
void adjust_volume(int volume) 
{
    gpio_bit_reset(GPIOB, GPIO_PIN_9);
    timer2_delay_us(400);
    for (int i = 0; i < volume + 1; i++) 
    {
        gpio_bit_set(GPIOB, GPIO_PIN_9);
        timer2_delay_us(100);
        gpio_bit_reset(GPIOB, GPIO_PIN_9);
        timer2_delay_us(100);
    }
    gpio_bit_set(GPIOB, GPIO_PIN_9);
    timer2_delay_ms(1000);
}

//
void beep_alarm(int level) 
{
    if (!Beep_one_flg)
    {
        gpio_bit_reset(GPIOB, GPIO_PIN_9);
        timer2_delay_us(800);//800
        for (int i = 0; i < level; i++) 
        {
            gpio_bit_set(GPIOB, GPIO_PIN_9);
            timer2_delay_us(200);//200
            gpio_bit_reset(GPIOB, GPIO_PIN_9);
            timer2_delay_us(200);
        }
        gpio_bit_set(GPIOB, GPIO_PIN_9);
        timer2_delay_ms(1);
        Beep_one_flg = 1;
        // Beep_one_flg_1 = 1;
    }
    
}

//停止蜂鸣器
void stop_alarm(void) 
{
    gpio_bit_reset(GPIOB, GPIO_PIN_9);
    timer2_delay_us(500);
}

// 封装test_beep只执行一次
void test_beep(void) 
{
    if (!Beep_one_flg_1)
    {
        gpio_bit_reset(GPIOB, GPIO_PIN_9);
        timer2_delay_us(400);
        for (int i = 0; i < 3; i++) 
        {
            gpio_bit_set(GPIOB, GPIO_PIN_9);
            timer2_delay_us(50);
            gpio_bit_reset(GPIOB, GPIO_PIN_9);
            timer2_delay_us(50);
        }
        gpio_bit_set(GPIOB, GPIO_PIN_9);
        timer2_delay_ms(1);
        // Beep_one_flg_1 = 1;
        // Beep_one_flg = 1;

    }

}


// if (gpio_input_bit_get(POWER_DETECT_GPIO, POWER_DETECT_PIN) == RESET)//判断是否已经断电
// {
//     // LCD_OFF(); //先关闭LCD显示
//     power_failure_handler();
//     //Beep_one_flg_1 = 1;
//     Yellow_Flg_test1 = 0; // 黄灯闪烁
//     Beepstop_Flg = 0;
//     delay_1ms(10);
//     Power_stop_Flg = 1;
// }
// else
// {
//     // Beep_one_flg_1 = 0;
//     Red_Flg_test1 = 0;
//     if (!Beepstop_Flg)
//     {
//         stop_alarm();
//         Red_alarm_light_False();
//         system_started = FALSE;
//         Beep_one_flg = 0;
//         // Beep_one_flg_1 = 0;
//     }
//     Beepstop_Flg = 1;
//     Power_stop_Flg = 2;
//     Beep_one_flg_1 = 0;
// }

// void BEEP_START(void)
// {
//     if (Red_Flg_test1 == 1)
//     {
//         test_beep();
//     }
// }

// void stop_all_peripherals(void) 
// {
// 	// 关闭外设
// 	rcu_periph_clock_disable(RCU_ADC0);
// 	rcu_periph_clock_disable(RCU_TIMER0);
// 	rcu_periph_clock_disable(RCU_USART0);
// 	rcu_periph_clock_disable(RCU_I2C0);
// }

void stop_all_peripherals_except_timer2(void) 
{
    // 关闭所有外设时钟（保留 TIMER2 & GPIOB）
    rcu_periph_clock_disable(RCU_AF);
    rcu_periph_clock_disable(RCU_GPIOA);
    // rcu_periph_clock_disable(RCU_GPIOC);
    rcu_periph_clock_disable(RCU_GPIOD);
    rcu_periph_clock_disable(RCU_ADC0);
    rcu_periph_clock_disable(RCU_ADC1);
    rcu_periph_clock_disable(RCU_DAC);
    rcu_periph_clock_disable(RCU_USART0);
    rcu_periph_clock_disable(RCU_USART1);
    rcu_periph_clock_disable(RCU_USART2);
    rcu_periph_clock_disable(RCU_SPI0);
    rcu_periph_clock_disable(RCU_SPI1);
    rcu_periph_clock_disable(RCU_I2C0);
    rcu_periph_clock_disable(RCU_I2C1);
//    rcu_periph_clock_disable(RCU_CAN0);
//    rcu_periph_clock_disable(RCU_CAN1);
    rcu_periph_clock_disable(RCU_BKPI);
    rcu_periph_clock_disable(RCU_WWDGT);
    rcu_periph_clock_disable(RCU_DMA0);
    rcu_periph_clock_disable(RCU_DMA1);
//    rcu_periph_clock_disable(RCU_FMC);
//    rcu_periph_clock_disable(RCU_SRAM);
//    rcu_periph_clock_disable(RCU_USBFS);
    
    // 关闭外设中断（可选）
    nvic_irq_disable(ADC0_1_IRQn);
    nvic_irq_disable(USART0_IRQn);
    nvic_irq_disable(USART1_IRQn);
    nvic_irq_disable(USART2_IRQn);
    nvic_irq_disable(SPI0_IRQn);
    nvic_irq_disable(SPI1_IRQn);
    nvic_irq_disable(I2C0_EV_IRQn);
    nvic_irq_disable(I2C1_EV_IRQn);
    // nvic_irq_disable(CAN0_RX0_IRQn);
    // nvic_irq_disable(CAN1_RX0_IRQn);

    // // 进入低功耗模式（可选）
    // __WFI();
}
		
void power_failure_handler(void) 
{
//    stop_all_peripherals_except_timer2();  // 关闭所有无关外设
    // while (1)
    // {
    // rcu_periph_clock_disable(RCU_GPIOD);
    LedOff();//关闭锁屏灯
    Flag.LockCnt = def_lock; //锁键时间 30000
    test_beep();
    delay_1ms(10);
    // beep_alarm(3);//
    
    Red_Flg_test1 = 1;
    delay_1ms(10);
    // __WFI();  // 让 CPU 进入低功耗等待
    // test_beep();
	// while (1)
    // {  
	// 	// 进入无限循环，仅让 LED 闪烁 & 蜂鸣器报警
	// LedOff();//关闭锁屏灯
    // Flag.LockCnt = def_lock; //锁键时间 30000
	// 	RED_FIG =! RED_FIG;
	// 	if(RED_FIG == 0)
	// 	{
	// 		Red_alarm_light_Ture();
	// 	}
	// 	else
	// 	{
	// 		Red_alarm_light_False();
	// 	}
	// 	timer2_delay_ms(500);

    //     // __WFI();  // 让 CPU 进入低功耗等待
	// }
}

//黄色灯，低压提示
void Low_yellow_led_On(void)
{
    // Alarm_type = LOW;
    // if (gpio_input_bit_get(POWER_DETECT_GPIO, POWER_DETECT_PIN) == SET)
    if(Power_stop_Flg == 2)
    {
        Red_alarm_light_Ture();
        green_led_Ture();
        LedOff();//关闭锁屏灯
		  Flag.IsLocked = 0;
        Flag.LockCnt = def_lock; //锁键时间 30000
    }
    
}

void Low_yellow_led_Off(void)
{
    Red_alarm_light_False();
    green_led_False();
    
    // // if (gpio_input_bit_get(POWER_DETECT_GPIO, POWER_DETECT_PIN) == SET)
    // // if(Power_stop_Flg == 2)
    // // {
    //     Red_alarm_light_False();
    //     // green_led_False();
    // // }
    // green_led_False();

}

#define Alarm_off 0   //不报警
#define Frist_alarm 1 //第一次报警（时间大于60min未充满）
#define Second_alarm 2//第二次报警（低于2kpa并持续两分钟）

extern uint16_t Warning_time_s;		        // 低于2kpa并持续两分钟报警的低压时间
void Low_pressure_alarm()
{
    switch (warn_state)
    {
        case Alarm_off:

            // Low_yellow_led_Off();           // 关闭黄灯
            Yellow_Flg_test1 = 0;           // 黄灯闪烁标志位置1
            // warn_para.LowPress_time = 0;    // 低压时间清零（时间大于60min未充满）
            // Warning_time_s = 0;             // 低压时间清零（低于2kpa并持续两分钟）
            // CurrentPARA.warn_info = 0;      // 低压（红字）显示标志位置0
            // Flag.PageNO = page_home;        // 回主页面
            // Power_stop_Flg = 0;
			// 	warn_state_flg = 0;

            break;

        case Frist_alarm:

            Flag.PageNO = page_low_pressure;//跳转到压力过低页面
            // Low_yellow_led_On();            // 打开黄灯
            Yellow_Flg_test1 = 1;           // 黄灯闪烁标志位置1
            beep_alarm(2);                  // 报警（中优先级）

            break;

        case Second_alarm:

            Flag.PageNO = page_low_pressure;//跳转到压力过低页面
            // Low_yellow_led_On();            // 打开黄灯
            Yellow_Flg_test1 = 1;           // 黄灯闪烁标志位置1
            beep_alarm(2);                  // 报警（中优先级）

            break;
        
        default:
            break;
    }
}


extern volatile uint8_t warn_state_flg; // 低压报警，0不报警，1第一种报警，2第二种报警

void Stop_power_30s()
{
    if (Power_stop_Flg == 1)
    {
        if (Power_off_time < 30)
        {
            // if(Power_stop_Flg == 2)
            // {
                // warn_state_flg = warn_state;
                // Power_off_time = 0;
                warn_button = 2; 
                // Beepstop_Flg = 0;
                // delay_1ms(10);
                // warn_state_flg = 0;
                // Beep_one_flg = 0;
                // warn_state_flg = 1;
            // }			
        }
        else
        {
            // warn_state = 0;
            // Power_off_time = 0;
            // warn_state_flg = 0;
            Warning_time_s = 0; // 重置低压时间
            warn_para.LowPress_time = 0;
            warn_state = 0;
            // warn_button = 2; 
            Flag.PageNO = page_home;
            // Power_off_time = 0;
        }
    }
    else
    {
        Power_off_time = 0;
    }
    
    // if (Power_stop_Flg == 2 && Power_off_time < 30)
	// {
	// 	// if(Power_stop_Flg == 2)
	// 	// {
	// 		// warn_state_flg = warn_state;
	// 		Power_off_time = 0;
    //         warn_button = 2; 
    //         // Beepstop_Flg = 0;
    //         // delay_1ms(10);
    //         // warn_state_flg = 0;
	// 		// Beep_one_flg = 0;
	// 		// warn_state_flg = 1;
	// 	// }			
	// }
	// else if(Power_off_time > 30)
	// {
	// 	// warn_state = 0;
	// 	// Power_off_time = 0;
	// 	// warn_state_flg = 0;
    //     Warning_time_s = 0; // 重置低压时间
	// 	warn_para.LowPress_time = 0;
    //     warn_state = 0;
    //     // warn_button = 2; 
	// 	Flag.PageNO = page_home;
    //     // Power_off_time = 0;
	// }
}

uint8_t debounce_gpio_read() 
{
    uint8_t sample1, sample2, sample3;

    // 进行三次采样
    sample1 = gpio_input_bit_get(POWER_DETECT_GPIO, POWER_DETECT_PIN);
    delay_1ms(5);
    sample2 = gpio_input_bit_get(POWER_DETECT_GPIO, POWER_DETECT_PIN);
    delay_1ms(5);
    sample3 = gpio_input_bit_get(POWER_DETECT_GPIO, POWER_DETECT_PIN);

    // 如果三次采样值都相同，则认为是稳定的电平
    if (sample1 == sample2 && sample2 == sample3) 
    {
        return sample1;
    } 
    else 
    {
        // 如果三次采样值不一致，返回上一次的采样值
        return sample3;
    }
}

void Power_stop_beep()
{
    uint8_t PC2_Value;

    PC2_Value = debounce_gpio_read();
    
    if (PC2_Value == RESET)//判断是否已经断电
    {
        
        // LCD_OFF(); //先关闭LCD显示
        // Yellow_Flg_test1 = 0; // 黄灯不闪烁
        power_failure_handler();
        Beep_one_flg_1 = 1;
        Yellow_Flg_test1 = 0; // 黄灯不闪烁
        Beepstop_Flg = 0;
        delay_1ms(10);
        Power_stop_Flg = 1;
    }
    else
    {
        // Beep_one_flg_1 = 0;
        Red_Flg_test1 = 0;
        if (!Beepstop_Flg)
        {
            stop_alarm();
            Red_alarm_light_False();
            Beep_one_flg_1 = 0;
            system_started = FALSE;
            Beep_one_flg = 0;
        }
        Beepstop_Flg = 1;
        Power_stop_Flg = 2;
        // Beep_one_flg_1 = 0;
    }
    Stop_power_30s();
}

// typedef enum {
//     STATE_IDLE,
//     STATE_BEEP,
//     STATE_DONE
// } BeepState;

// BeepState beep_state = STATE_IDLE;

// void beep_state_machine(void)
// {
//     switch (beep_state)
//     {
//         case STATE_IDLE:
//             // 等待某个条件触发
//             if (trigger_flag)
//             {
//                 beep_state = STATE_BEEP;
//             }
//             break;

//         case STATE_BEEP:
//             test_beep(); // 执行一次蜂鸣
//             beep_state = STATE_DONE;
//             break;

//         case STATE_DONE:
//             // 保持不动，直到某种复位条件触发
//             break;
//     }
// }



// uint8_t debounce_gpio_read(POWER_DETECT_GPIO, POWER_DETECT_PIN)
// {
//     uint8_t count = 0;
//     uint8_t value = gpio_input_bit_get(POWER_DETECT_GPIO, POWER_DETECT_PIN);
//     for (int i = 0; i < 10; i++) 
//     {
//         delay_1ms(1);
//         if (gpio_input_bit_get(POWER_DETECT_GPIO, POWER_DETECT_PIN) == value) 
//         {
//             count++;
//         }
//     }
//     if (count >= 8) 
//     {
//         return value;
//     }
//     return !value;
// }



// if (gpio_input_bit_get(POWER_DETECT_GPIO, POWER_DETECT_PIN) == RESET)
		// 	{
		// 		test_beep();
		// 		// Red_Flg_test1 = 1;
		// 		// RED_FIG = 0;
		// 		while (1)
		// 		{
		// 			RED_FIG =! RED_FIG;
		// 			if (RED_FIG == 0)
		// 			{
		// 				Red_alarm_light_Ture();
		// 			}
		// 			else
		// 			{
		// 				Red_alarm_light_False();
		// 			}
		// 			timer2_delay_ms(500);
		// 		}
		// 	}



// void Beep_Init(void)
// {
//     rcu_periph_clock_enable(RCU_GPIOB);
//     gpio_init(GPIOB, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9);
//     gpio_bit_reset(GPIOB, GPIO_PIN_9);
//     adjust_volume(LOW);
// }


// #include "gd32f10x.h"
// #include "general_config.h"

// void DWT_Delay_Init(void)
// {
//    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;  // 使能 DWT
//    DWT->CYCCNT = 0;  // 清零计数器
//    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;  // 启用 DWT 计数器
// }

// void DWT_Delay_Us(uint32_t nus)
// {
//    uint32_t start_tick = DWT->CYCCNT;
//    // uint32_t delay_ticks = (HAL_RCC_GetHCLKFreq() / 1000000) * nus; // 计算目标周期数
//    uint32_t delay_ticks = (SystemCoreClock / 1000000) * nus; // 计算目标周期数
   

//    while ((DWT->CYCCNT - start_tick) < delay_ticks); // 等待计数器达到目标值
// }

// /**
// * @description: 音量调节，参数为1，2，3对应高，中，低音量（注意顺序）
// * @param {int} volume
// * @return {*}
// */
// void adjust_volume(int volume)
// {

// //   HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_RESET);
//  gpio_bit_write(GPIOB, GPIO_PIN_9, RESET);
//  DWT_Delay_Us(400);
//  for(int i = 0 ;i < volume+1;i++)
//  {
//    // HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_SET);
//    gpio_bit_write(GPIOB, GPIO_PIN_9, SET);
//    DWT_Delay_Us(100);
//    // HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_RESET);
//    gpio_bit_write(GPIOB, GPIO_PIN_9, RESET);
//    DWT_Delay_Us(100);
//  }
// //   HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_SET);
//  gpio_bit_write(GPIOB, GPIO_PIN_9, SET);
// //   HAL_Delay(1000);
//  delay_1ms(1000);
// }
// /**
// * @description: 优先级报警，1，2，3对应低，中，高报警
// * @param {int} level
// * @return {*}
// */
// void beep_alarm(int level)
// {
//    uint32_t primask = __get_PRIMASK();//记录当前中断
//    __disable_irq();
   

// //   HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_RESET);
//  gpio_bit_write(GPIOB, GPIO_PIN_9, RESET);
//  DWT_Delay_Us(800);
//  for(int i = 0 ; i<level;i++)
//  {
//    // HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_SET);
//    gpio_bit_write(GPIOB, GPIO_PIN_9, SET);
//    DWT_Delay_Us(200);
//    // HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_RESET);
//    gpio_bit_write(GPIOB, GPIO_PIN_9, RESET);
//    DWT_Delay_Us(200);
//  }
// //   HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_SET);
//  gpio_bit_write(GPIOB, GPIO_PIN_9, SET);
//  __set_PRIMASK(primask);

// }

// void stop_alarm(void)
// {
// //   HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_RESET);
//  gpio_bit_write(GPIOB, GPIO_PIN_9, RESET);
//  DWT_Delay_Us(500);
// //  log_i("stop alarm");
// }
// void test_beep(void)
// {
// //   HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_RESET);
//  gpio_bit_write(GPIOB, GPIO_PIN_9, RESET);
//  DWT_Delay_Us(400);
//  for(int i = 0; i < 3;i++)
//  {
//    // HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_SET);
//    gpio_bit_write(GPIOB, GPIO_PIN_9, SET);
//    DWT_Delay_Us(50);
//    // HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_RESET);
//    gpio_bit_write(GPIOB, GPIO_PIN_9, RESET);
//    DWT_Delay_Us(50);
//  }
// //   HAL_GPIO_WritePin(Beep_GPIO_Port,Beep_Pin,GPIO_PIN_SET);
//  gpio_bit_write(GPIOB, GPIO_PIN_9, SET);
// //   HAL_Delay(1);
//  delay_1ms(1);

// }







//未测试// #include "gd32f10x.h"

// #define ALARM_PIN GPIO_PIN_9   // PWM 输出引脚
// #define ALARM_PORT GPIOB       // PWM 端口

// void PWM_GPIO_Init(void)
// {
//     rcu_periph_clock_enable(RCU_GPIOB);  // 使能 GPIOB 时钟
//     rcu_periph_clock_enable(RCU_TIMER2); // 使能 TIM2 时钟

//     gpio_init(ALARM_PORT, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, ALARM_PIN);
//     gpio_bit_reset(ALARM_PORT,ALARM_PIN);
// }

// void delay_us(uint32_t us)
// {
//     uint32_t start = SysTick->VAL;  // 读取当前 Systick 计数值
//     uint32_t ticks = us * (SystemCoreClock / 1000000); // 计算 us 对应的时钟周期数

//     while ((SysTick->VAL - start) < ticks); // 等待计数到达目标值
// }

// void TIM2_PWM_Init(void)
// {
//     timer_parameter_struct timer_initpara;
//     timer_oc_parameter_struct timer_ocinit;

//     timer_deinit(TIMER2);

//     // **设置 TIM2 频率**
//     timer_initpara.prescaler = 71;  // 72MHz / (71+1) = 1MHz 计数频率
//     timer_initpara.alignedmode = TIMER_COUNTER_EDGE;
//     timer_initpara.counterdirection = TIMER_COUNTER_UP;
//     timer_initpara.period = 150;    // 1MHz / 150 = **6.67kHz 频率**
//     timer_initpara.clockdivision = TIMER_CKDIV_DIV1;
//     timer_initpara.repetitioncounter = 0;
//     timer_init(TIMER2, &timer_initpara);

//     // **配置 PWM**
//     timer_ocinit.ocpolarity = TIMER_OC_POLARITY_HIGH;
//     timer_ocinit.outputstate = TIMER_CCX_ENABLE;
//     timer_ocinit.ocidlestate = TIMER_OC_IDLE_STATE_LOW;
//     timer_channel_output_config(TIMER2, TIMER_CH_1, &timer_ocinit);

//     timer_channel_output_pulse_value_config(TIMER2, TIMER_CH_1, 50); // **50us 高电平**
//     timer_channel_output_mode_config(TIMER2, TIMER_CH_1, TIMER_OC_MODE_PWM0);
//     timer_channel_output_shadow_config(TIMER2, TIMER_CH_1, TIMER_OC_SHADOW_DISABLE);

//     timer_enable(TIMER2); // 启动 PWM
// }


// void Send_Pulse_PWM(uint8_t count)
// {
//     timer_enable(TIMER2); // 开启 PWM 输出

//     // 计算需要的时间
//     uint32_t pulse_time = count * 150;  // 每个脉冲 150us，总时间 = count * 150us
//     delay_us(pulse_time);

//     timer_disable(TIMER2); // 关闭 PWM
//     gpio_bit_set(ALARM_PORT, ALARM_PIN); // 保持高电平
// }

// void Set_Alarm_PWM(uint8_t level)
// {
//     switch (level)
//     {
//     case 0:
//         Send_Pulse_PWM(1); // BEEP 声音
//         break;
//     case 1:
//         Send_Pulse_PWM(2); // 低优先级报警
//         break;
//     case 2:
//         Send_Pulse_PWM(3); // 中优先级报警
//         break;
//     case 3:
//         Send_Pulse_PWM(4); // 高优先级报警
//         break;
//     case 4:
//         Send_Pulse_PWM(5); // 高音量
//         break;
//     case 5:
//         Send_Pulse_PWM(6); // 中音量
//         break;
//     case 6:
//         Send_Pulse_PWM(7); // 低音量
//         break;
//     default:
//         gpio_bit_reset(ALARM_PORT, ALARM_PIN); // 停止报警
//         break;
//     }
// }



